home *** CD-ROM | disk | FTP | other *** search
/ Ham Radio 2000 / Ham Radio 2000.iso / ham2000 / tcp_ip / os2 / pmnos11s / buckbook.c < prev    next >
C/C++ Source or Header  |  1993-07-30  |  24KB  |  884 lines
  1. /*
  2.    Fred Peachman KB7YW
  3.    7186 Northview Drive
  4.    Brookfield, OH 44403
  5.    Sun  03-01-1992
  6.  
  7.    This is a substitute for N4PCR's callsign server. The intent is to replace
  8.    N4PCR's callbook.c with this file - and have a callsign server that will
  9.    run off Buckmaster's CD-ROM: the October 1991 "HAM CALL" CD.
  10.  
  11.    The CD-ROM must be configured with a driver installed in config.sys,
  12.    and the mscdex.exe TSR must be running.
  13.  
  14.    The callserver database commands will configure the cd-rom.
  15.  
  16.    config.h must #define CALLCLI or CALLSERVER. If CALLSERVER is #define'd
  17.    CALLCLI is forced on by config.h. Only CALLCLI can be #define'd separately
  18.    of CALLSERVER so it is the default condition for compilation of this
  19.    module - which won't used at all if neither CALLCLI nor CALLSERVER are
  20.    #define'd in config.h.
  21.  */
  22.  
  23. #include <stdio.h>
  24. #include <string.h>
  25. #include <time.h>
  26. #include <sys/timeb.h>
  27. #include "global.h"
  28. #include "files.h"
  29. #include <stdlib.h>
  30. #include  <dos.h>
  31. #include <alloc.h>
  32. #include <ctype.h>
  33. #include <fcntl.h>
  34. #include <io.h>
  35.  
  36. #include "cmdparse.h"
  37. #include "config.h"
  38.  
  39. #ifdef CALLSERVER
  40. /* CD-ROM code by Fred Peachman KB7YW */
  41. char *CDROM = NULLCHAR;
  42. #endif
  43.  
  44. char  *Callserver = NULLCHAR;
  45.  
  46. /*struct database_activity
  47.   One of these structs gets filled out by init -
  48.   initializes data base for calls from hamcall.c -
  49.   should be able to handle generic functions across different data base
  50.   formats.
  51.  */
  52.   struct database_activity {
  53.     int type;                     /* for checking data/function formats*/
  54. #define USA 0
  55. #define CANADA 1
  56.     int  handle;                  /* -1 if unitialized  */
  57.     unsigned long record;         /* current record #                 */
  58.     void *record_buf;           /* where to read the record to      */
  59.   };
  60.  
  61.   struct months {
  62.     char *m;  /* name of month  */
  63.     int  d;   /* days in month  */
  64.   };
  65. /* The Buckmaster HAM CALL CD format for U.S. Callsign database       */
  66.   struct usa  {
  67.     char callsign[6];   /* None of these fields are ASCIIZ so be careful */
  68.     char lastname[24];
  69.     char firstname[11];
  70.     char middle[1];
  71.     char street[35];
  72.     char city[20];
  73.     char state[2];
  74.     char zip[5];
  75.     char fluff[8];      /* supreme nothingness                            */
  76.     char exp[2];        /* 'X3' if license expired                        */
  77.     char born[2];       /* Last two digits of year of birth  i.e. '54     */
  78.     char expiryr[2];    /* Last two digits of year of license expiration  */
  79.     char expirday[3];   /* The day of the year that license expires       */
  80.     char validyr[2];    /* year that license was issued                   */
  81.     char validday[3];   /* day of the year that license was issued        */
  82.     char class[1];      /* 1 letter license classification                */
  83.     char endline[2];    /* file marker                                    */
  84.   };
  85.  
  86. /* The Buckmaster HAM CALL CD format for Canadian Callsign database
  87.    It is 0x9a bytes long (154) The first record has a blank callsign field
  88.    that should be no problem!                                             */
  89.  
  90.   struct canada  {
  91.     char callsign[8];
  92.     char name[0xe8 - 0xa2];
  93.     char street[0x10a - 0xe8];
  94.     char town[0x121-0x10a];
  95.     char province[0x12c-0x121];
  96.     char zip[6];
  97.     char endline[2];
  98.   };
  99.                     /* generic function calls: headers */
  100. static int
  101. init(struct database_activity *db,int type,int s);
  102. static int
  103. close_down(struct database_activity *db);
  104. static void
  105.  disp(char *cfield, int siz, int s);
  106. static int
  107. readrec(struct database_activity *db);
  108. static int
  109. displayrec(struct database_activity *db, int s);
  110. static int
  111. find_call(struct database_activity *db, char *callsign);
  112. static int
  113. make_mask(char *mask, char *callsign, int s);
  114.  
  115. static int
  116. docallserver_hostname(int argc,char *argv[],void *p);
  117. static int
  118. docallserver_databases(int argc,char *argv[],void *p);
  119.  
  120.                         /* for u.s.a database:  */
  121. static int
  122. display_usa(void *,int s);
  123. static int
  124. comp_usa_calls(char *, char *);
  125.  
  126.                         /* for canada database  */
  127. static int
  128. display_canada(void *,int s);
  129. static int
  130. comp_canada_calls(char *, char *);
  131.  
  132. /* most of this module is server code, but some is client: CALLCLI is by
  133.    default - forced on in config.h whenever CALLSERVER is #define'd */
  134. #ifdef CALLSERVER
  135.  
  136. /* How many different databases are we supporting right now?              */
  137. #define DATABASE_TYPES 2
  138.  
  139. /* how many passes should we make before we give up (in find_call)?    */
  140. #define MAXREADS 30
  141. /*----------------------------------------------------------------------------
  142.     Here are arrays of variables to use depending on which database is
  143.     needed. In each array make sure the value order is same as defs for
  144.     database_activity.types i.e. USA, CANADA, ....
  145.  
  146.     In order to tack on another database, add an element for each of these
  147.     arrays, increment the definition for DATABASE_TYPES (above), and
  148.     tell your program how to tell init to use the new one.  In this
  149.     module the launcher (cb_lookup) will figure out which database to
  150.     initialize ("init(type, callsign,s)").
  151.  
  152.     Basically for the new database you would only need to specify its file
  153.     name in database[], write a display function and specify it in
  154.     displayfunc[], specify the size of one record in record_size[],
  155.     write a callsign comparison function and specify it in compare_calls[],
  156.     and specify the byte offset of the callsign field within a record -
  157.     specify this offset in call_offset[] - it will probably be 0 anyway.
  158.  
  159.     You need to write something in cb_lookup to tell init when to initialize
  160.     your new database. Basically if "call" satisfies inspection, initialize
  161.     the appropriate database.
  162.  */
  163.  
  164. char *database[DATABASE_TYPES]  = {
  165.   { NULLCHAR  }, /* "S:\\HAM0\\HAMCALL.129"},  USA  */
  166.   { NULLCHAR  }  /* "S:\\HAM0\\CANADA2.DAT"}   CANADA */
  167. };
  168.  
  169. char *database_label[DATABASE_TYPES]  = {
  170.   { "usa"},{"canadian"}
  171. };
  172.  
  173. int (*displayfunc[DATABASE_TYPES])(void *, int) = {
  174.   { display_usa },
  175.   { display_canada }
  176. };
  177.  
  178. /* basic record size, in bytes, in each database  */
  179. int record_size[DATABASE_TYPES] =   {   129, 154  };
  180.  
  181.             /* How fresh is this stuff in the database?  */
  182. static char *Volume = "October 1991";
  183.  
  184.             /* number of records in each type of database */
  185. unsigned long records[DATABASE_TYPES];
  186.  
  187.        /* The database-specific callsign comparison procedure  */
  188. int (*compare_calls[DATABASE_TYPES])(char *,char *) = {
  189.   {comp_usa_calls},{comp_canada_calls}
  190. };
  191. /*      At what offset within a database struct is the callsign located?
  192.                Look at struct usa and struct canada above
  193.  */
  194. int call_offset[DATABASE_TYPES] = { 0,0 };
  195.  
  196. char *BusyServer = "\n\nThe callsign server is busy right now\n\
  197. .... please call back later\n\n";
  198.  
  199. static char *TAB = "        ";
  200.  
  201.                    /* for use in display_usa */
  202. struct months month[12] = {
  203.   {"January", 31},{"February",28},{"March",31},{"April",30},{"May",31},
  204.   {"June",30},{"July",31},{"August",31},{"September",30},{"October",31},
  205.   {"November",30},{"December",31}
  206.   };
  207. /*----------------------------------------------------------------------------
  208. /* --------------- Generic (database-independent) functions ----------------*/
  209. /*----------------------------------------------------------------------------
  210.   Initialize a database activity struct. this consists of making sure
  211.   the database file is opened and that the number of records in that
  212.   file is computed. Also a record_buf is malloced for each db.
  213.  */
  214. static int
  215. init(db, type, s)
  216. struct database_activity *db;
  217. int type;
  218. int s;
  219. {
  220. long tmp;
  221. int i;
  222. extern char *Callserver;  /* declared in calldbd.c  */
  223.   if ((type < 0) || (type >= DATABASE_TYPES))  return -1;
  224.  
  225.   db->type = type;
  226.  
  227.   i = db->handle = _open(database[type], O_RDONLY | O_BINARY);
  228.   if (i == -1) {
  229.     usprintf(s,"%s",BusyServer);
  230.     return 0;
  231.   }
  232.   for (i = 0; i < 50; i++)  pwait(NULL);
  233.   /* The CD-ROM is a slow device!! - give other processes lots of slack */
  234.  
  235.   tmp = filelength(db->handle);
  236. /*   if (tmp == -1L)  {
  237.     usprintf(s,"Error reading length of file \"%s\"\n\
  238.     please report to the sysop at %s\n",database[type], Callserver);
  239.     return -1;
  240.   }
  241. */
  242.   records[type] = tmp/((long) record_size[type]);
  243.  
  244.   db->record_buf = (char *)malloc(record_size[type]);
  245.   if (db->record_buf == NULL) {
  246.     usprintf(s,"%s",BusyServer);  /* No memory to allocate, actually  */
  247.     return -1;
  248.   }
  249.   return 0;
  250. }
  251.  
  252. static int
  253. close_down(db)
  254. struct database_activity* db;
  255. {
  256.   free(db->record_buf);
  257.   _close(db->handle);
  258. }
  259. static int
  260. invalid_callsign(callsign, s)
  261. char *callsign;
  262. int s;
  263. {
  264.   usprintf(s,"\n\n\"%s\" is an invalid callsign\n\n", callsign);
  265.   return -1;
  266. }
  267.  
  268. /* make_mask makes a Buckmaster-compatible mask out of the callsign.
  269.   caller must allocate 6 bytes exactly for "mask" or 7 to make an ascii
  270.   string out of it.
  271.  
  272.   callsign is the callsign we are looking to match; mask is the same
  273.   callsign only padded to Left with a space if necessary to keep the
  274.   callsign digit at position 2 (starting with 0), and padded with spaces
  275.   to the right if necessary to make sure the mask is exactly 6 digits
  276.   long.
  277.  
  278.   This routine will work right for US or Canadian callsigns, but NOT with
  279.   foreign callsigns (that contain more than one numeric character) it
  280.   will fail!
  281.  */
  282.  
  283. static int
  284. make_mask(mask, callsign,s)
  285. char *mask;
  286. char *callsign;
  287. int s;
  288. {
  289. int j, k, len, already=0;
  290. char *q, *p;
  291. char tmp[7];
  292.  
  293.   len = strlen(callsign);
  294.  
  295.   /* there must be only ONE digit-character at position 1 or 2
  296.       (starting from 0)  */
  297.   q = callsign;
  298.   already = 0;
  299.   for (j = 0; j < len; j++)   {
  300.     if (isdigit(*q++))  {
  301.       if (!(already++)) k = j;/* already counts the number of digit chars */
  302.       else return invalid_callsign(callsign,s);
  303.     }
  304.   }
  305.   if ((k < 1) || ( k > 2))  return invalid_callsign(callsign,s);
  306.  
  307. /* FINALLY, Buckmaster pads to the left with spaces to position the digit at
  308.   mask[2] */
  309.  
  310.   q = mask;
  311.   for (j = 0; j < 6; j++) *q++ = ' '; /* initialize!  */
  312.  
  313.   p = callsign;
  314.   q = mask;
  315.  
  316.   switch (k)  {
  317.     case 1:
  318.     *q++ = ' '; /* left-pad with a space  */
  319.     break;
  320.  
  321.     case 2:
  322.     break;
  323.  
  324.     default:
  325.     break;
  326. /*  usprintf(s,"Error in make_mask %s line %d\n",__FILE__,__LINE__);
  327.     exit(255);
  328. */
  329.   }
  330.  
  331.   for (j = 0; j < len; j++) *q++ = *p++;
  332.  
  333.   return ((int) (mask[2]) &0x0f); /* returns digit of the valid U.S. callsign */
  334. }
  335.  
  336. /* a method for display of non-ASCIIZ strings */
  337. static void
  338. disp(cfield,siz,s)
  339. char *cfield;
  340. int siz;
  341. int s;
  342. {
  343. char *q;
  344. int i, sw=0;
  345.  
  346.   q = cfield;
  347.   for (i = 0; i < siz; i++) {
  348.     if ((!sw) || (*q != ' ')) usputc(s, (int) *q, stdout);
  349.     if (*q == ' ') sw = 1;
  350.     else sw = 0;  /* We will print out one space before we quit!  */
  351.     q++;
  352.   }
  353. }
  354. static int
  355. readrec(db)
  356. struct database_activity *db;
  357. {
  358. unsigned long tmp, filepointer;
  359. size_t n;
  360. int st;
  361.  
  362.   st = db->type;
  363.   filepointer = db->record*((long) record_size[st]);
  364.   tmp = lseek(db->handle, filepointer,SEEK_SET);
  365. /*
  366.   if (tmp != filepointer) {
  367.     usprintf(s,"filepointer moved to %08lu\n", tmp);
  368.     return -1;
  369.   }
  370. */
  371.   n = _read(db->handle, db->record_buf,record_size[st]);
  372. /*
  373.   if (n != record_size[st]) {
  374.      usprintf(s,"Error reading database\n");
  375.      return -1;
  376.   }
  377.   else
  378. */
  379.     return 0;
  380. }
  381.  
  382. static int
  383. displayrec(db,s)
  384. struct database_activity *db;
  385. int s;
  386. {
  387. int (*func)(void *v, int s);
  388.  
  389.   func = displayfunc[db->type];
  390.   usprintf(s,"\n%s*** Record # % 8lu:***\n",TAB, db->record);
  391.   func(db->record_buf,s);
  392.   return 0;
  393. }
  394. /* find_call: Find the record number that matches the callsign. For any
  395.    callbook data where the records are all of the same length. The
  396.    returned record value is found as db->record.
  397.  
  398.    If the input callsign needs to be converted to a search mask in any
  399.    way, do it then call findcall.
  400.  
  401.    The returned int value is the number of records read during the search
  402.    process.
  403.  */
  404.  
  405. static int
  406. find_call(db, callsign)
  407. struct database_activity *db;
  408. char *callsign;
  409. {
  410. int i, ret, met= 0, reads = 0;
  411. long ra,rz;  /* first, middle, last record numbers */
  412. int (*comp)(char *, char *);
  413. int st;
  414. char *rec_call;
  415.  
  416.   st = db->type;  /* determine database structure type  */
  417.   comp = compare_calls[st];
  418. /* set initial pointers */
  419.   ra = 0L;
  420.   rz = records[st] - 1L;
  421.   db->record = (ra + rz)/2L;  /* go for the middle  */
  422.  
  423.   rec_call = (char *)db->record_buf + call_offset[st];
  424.   ret = 1;
  425.   while (ret != 0)  {
  426.     readrec(db);  /* read in the data pointed to by db->record  */
  427.     for (i=0; i < 50; i++)
  428.       pwait(NULL);  /* sit back and let other processes run for a while.
  429.       The CD-ROM is a slow-access device so lots of other processes may
  430.       be waiting or trying to run - like the keyboard!!! */
  431.  
  432.     reads++;
  433.     ret = comp(callsign, rec_call);
  434.  
  435.     if (ret < 0)  /* callsign < record's callsign field  */
  436.       rz = db->record - 1L;
  437.     else if (ret > 0)  /* callsign > record's callsign field  */
  438.       ra = db->record + 1L;
  439.     else return reads;
  440.  
  441.     if (reads == MAXREADS) return -1;  /* Abnormal return  */
  442.     else if (ra >= rz)  {
  443.       if (met)  return -1;
  444.       else  met = 1;  /* catch this if it happens a second time!  */
  445.     }
  446.     db->record = (ra + rz)/2L;
  447.   }
  448.   /* not reached  */
  449. }
  450. /*---------------- ROUTINES FOR U.S. CALLSIGN DATABASE ----------------------*/
  451.  
  452. /* getdaynum: given a character array 'p' of 'siz' elements, convert the
  453.    array to an ASCIIZ string, return the integer value that it
  454.    represents.
  455.  */
  456. static int
  457. getdaynum(p,siz)
  458. char *p;
  459. int siz;
  460. {
  461. char *q, tmp[80];
  462. int ret, i;
  463.  
  464.   q = p;
  465.   for (i = 0; i < siz; i++) {
  466.     tmp[i] = *q++;
  467.   }
  468.   tmp[i] = '\0';
  469.  
  470.   ret = atoi(tmp);
  471.  
  472.   return ret;
  473. }
  474. /* yrval:
  475.    Take the two-letter year code and determine if we have a year that is in
  476.    the 1900's or the 21st century. Return a proper integer answer:
  477.    i.e. "2002" or "1998".
  478.  */
  479. static int
  480. yrval(yrin)
  481. char *yrin;
  482. {
  483. int i, num;
  484.  
  485.     num = getdaynum(yrin, 2);
  486.  
  487.     if (num > 90) num += 1900;
  488.     else num += 2000;
  489.     return num; /* an integer */
  490. }
  491. /* day_calc: given the 3-element character array 'day' and the 2-element
  492.    character array 'yr', construct a string that returns the date for
  493.    that year, in the form "February 28, 2002" */
  494.  
  495. static char *
  496. day_calc(day, daystr, yr)
  497. char day[3];
  498. char *daystr;
  499. char yr[2];
  500. {
  501. int i, daynum, subt, year, t;
  502. char *q, tmp[4];
  503. int leap = 0;
  504.  
  505.     year = yrval(yr);
  506.  
  507.     if (!(year%4))  leap = 1; /* evenly divisible by four means leap year */
  508.  
  509.     daynum = getdaynum(day, 3);
  510.     if (daynum == 0)  return NULL;
  511.  
  512.  
  513.     subt = 0;
  514.     for (i = 0; i < 12; i++)  {
  515.       if (((t = subt + ((i == 1) ? leap : 0) + month[i].d)) > daynum) break;
  516.       else (subt = t);
  517.     }
  518.     t = daynum - subt;
  519.     if (i == 12)  daystr[0] = '\0';
  520.     else  sprintf(daystr,"%s %d, %d", (t > 0 ? month[i].m : month[--i].m),
  521.                   (t > 0 ? t : month[i].d + ((i==1) ? leap : 0)),
  522.                   year);
  523.     return daystr;
  524. }
  525. /* comp_usa_calls compares the sought-for callsign with a mask of the
  526.    type encountered in the callsign field of a struct usa,
  527.  
  528.   returns 0 if they match, -1 if mask1 < mask2, 1 if mask1 > mask2.
  529.   mask1 is the callsign requested, mask2 is the database callsign from
  530.   the record under test for match.
  531.  */
  532. static int
  533. comp_usa_calls(mask1, mask2)
  534. char mask1[6];
  535. char mask2[6];
  536. {
  537. int i;
  538. char *p, *q;
  539.  
  540.   /* This is in accordance with the way that Buckmaster orders callsigns
  541.      on its CD-ROM database, so follow along:
  542.    */
  543.  
  544.   p = &mask1[2], q = &mask2[2];
  545.   for (i =2; i < 6; i++)  {
  546.     if (*p != *q)  return (int) *p - (int) *q;
  547.     p++, q++;
  548.   }
  549.   p = mask1, q = mask2;
  550.   for (i =0; i < 2; i++)  {
  551.     if (*p != *q)  return (int) *p - (int) *q;
  552.     p++, q++;
  553.   }
  554.   return 0;
  555. }
  556.  
  557.  
  558. /*
  559.     Buckmaster CD-ROM October 1991
  560.       *** Record #   452100:***
  561. Call:   KB7YW
  562.         FREDERICK A PEACHMAN
  563.         7186 NORTHVIEW DR
  564.         BROOKFIELD , OH 44403
  565. Born:   1954
  566. Class:  EXTRA
  567. Exp:    March 29, 1998
  568.  */
  569. static int
  570. display_usa(us,s)
  571. void *us;
  572. int s;
  573. {
  574. struct usa *u;
  575. char daystr[20];
  576. int yeardate;
  577.  
  578.   u = (struct usa *)us;
  579.   usprintf(s, "CALL:   ");
  580.   disp(u->callsign,sizeof(u->callsign),s);
  581.   usprintf(s,"\n%s", TAB);
  582.   disp(u->firstname,sizeof(u->firstname),s);
  583.   disp(u->middle,sizeof(u->middle),s);
  584.   usprintf(s," ");
  585.   disp(u->lastname,sizeof(u->lastname),s);
  586.   usprintf(s,"\n%s", TAB);
  587.   disp(u->street,sizeof(u->street),s);
  588.   usprintf(s,"\n%s", TAB);
  589.   disp(u->city,sizeof(u->city),s);
  590.   usprintf(s,", ");
  591.   disp(u->state,sizeof(u->state),s);
  592.   usprintf(s," ");
  593.   disp(u->zip,sizeof(u->zip),s);
  594.   if (u->born[0] != '-')  {
  595.     usprintf(s,"\nBorn:   19");
  596.     disp(u->born,sizeof(u->born),s);
  597.   }
  598.   usprintf(s,"\nClass:  ");
  599.  
  600.   switch(u->class[0])   {
  601.     case 'N':
  602.     usprintf(s,"NOVICE");
  603.     break;
  604.  
  605.     case 'T':
  606.     usprintf(s,"TECHNICIAN");
  607.     break;
  608.  
  609.     case 'C':
  610.     usprintf(s, "CLUB STATION");
  611.     break;
  612.  
  613.     case 'G':
  614.     usprintf(s,"GENERAL");
  615.     break;
  616.  
  617.     case 'A':
  618.     usprintf(s,"ADVANCED");
  619.     break;
  620.  
  621.     case 'E':
  622.     usprintf(s,"EXTRA");
  623.     break;
  624.  
  625.     default:
  626.     usprintf(s,"%c", u->class[0]);
  627.   }
  628.   usprintf(s,"\n");
  629.  
  630.   yeardate = yrval(u->expiryr);
  631.   if (day_calc(u->expirday, daystr, u->expiryr) != NULL)  {
  632.     if (daystr[0] != '\0')  {
  633.       if ((u->exp[0] == ' ') || (yeardate > 2000))  {
  634.         usprintf(s,"Expires:");
  635.         usprintf(s,"%s\n", daystr);
  636.       }
  637.       else usprintf(s,"%sUnknown Expiration Date\n",TAB);
  638.     }
  639.     else usprintf(s,"%sUnknown Expiration Date\n",TAB);
  640.   }
  641.   return 0;
  642. }
  643.  
  644. /*---------- Procedures specific to Canadian Callsign DataBase----------------*/
  645. static int
  646. display_canada(us,s)
  647. void *us;
  648. int s;
  649. {
  650. struct canada *u;
  651. #define DISP(x) {usprintf(s,"\n        ");\
  652.                  disp(x, sizeof(x),s);}
  653.  
  654.   u = (struct canada *) us;
  655.  
  656.   DISP(u->callsign);
  657.   DISP(u->name);
  658.   DISP(u->street);
  659.   DISP(u->town);
  660.   disp(u->zip, sizeof(u->zip),s);
  661.   usprintf(s,"\n");
  662.   usprintf(s,"%sCANADA\n",TAB);
  663.  
  664.   return 0;
  665. }
  666. /* comp_canada_calls compares the sought-for callsign with a mask of the
  667.    type encountered in the callsign field of a struct canada,
  668.  
  669.   returns 0 if they match, -1 if mask1 < mask2, 1 if mask1 > mask2.
  670.   mask1 is the callsign requested, mask2 is the database callsign from
  671.   the record under test for match.
  672.  */
  673.  
  674. static int
  675. comp_canada_calls(mask1, mask2)
  676. char mask1[6];
  677. char mask2[6];
  678. {
  679. int i;
  680. char *p, *q;
  681.  
  682.   p = mask1, q = mask2;
  683.   for (i =0; i < 6; i++)  {
  684.     if (*p != *q)  return (int) *p - (int) *q;
  685.     p++, q++;
  686.   }
  687.   return 0;
  688. }
  689. /* One of three public  functions!  */
  690. int
  691. cb_lookup(s,call)
  692. int s;
  693. char  *call;
  694. {
  695. /* This is the launcher.  Get rid of any callsign validity-checking code
  696.   that happens before calling cb_lookup. Eventually we will have to
  697.   launch the US, Canadian, or foreign Buckmaster CD databases. For right
  698.   now, tho, we only have USA and CANADA.
  699.  */
  700. char *q;
  701. int len, j;
  702. char mask[7];
  703. struct database_activity DA;
  704. char *cant = "Can't handle callsign \"%s\"\n";
  705.  
  706.                   /* FIRST TEST CALLSIGN FOR VALIDITY */
  707.  
  708.   /* Buckmaster only matches callsigns of 4 to 6 letters in length  */
  709.   len = strlen(call);
  710.   if ((len < 4) || (len > 6)) return invalid_callsign(call,s);
  711.  
  712.   for (j = 0; j < 6; j++) call[j] = toupper(call[j]);
  713.  
  714.                   /* every character must be alphanumeric */
  715.   q = call;
  716.   for (j = 0; j < len; j++) if (!(isalnum(*q++)))
  717.     return invalid_callsign(call,s);
  718.  
  719.   q = call;
  720.   switch (*q) {
  721.     case 'A':
  722.     case 'K':
  723.     case 'N':
  724.     case 'W':
  725.     if ((init(&DA, USA, s)) == -1)  return 0;
  726.     if ((make_mask(mask, call, s)) == -1) {
  727.       close_down(&DA);
  728.       return 0;
  729.     }
  730.     break;
  731.  
  732.     case 'V':
  733.       if ((strncmp(call,"VO",2) == 0) || (strncmp(call,"VE",2) == 0)) {
  734.         if ((init(&DA, CANADA, s)) == -1)  return 0;
  735.         if ((make_mask(mask, call, s)) == -1)   {
  736.           close_down(&DA);
  737.           return 0;
  738.         }
  739.       }
  740.       else  {
  741.         usprintf(s,cant,call);
  742.         return 0;
  743.       }
  744.       break;
  745.  
  746.     default:
  747.         usprintf(s,cant,call);
  748.       return 0;
  749.   }
  750.  
  751.   if ((find_call(&DA,mask)) == -1)
  752.     usprintf(s, "\n\nCallsign \"%s\" not found\n\n",call);
  753.   else {
  754.     displayrec(&DA,s);
  755.     usprintf(s,"\n%sDatabase date: %s\n\n\n",TAB, Volume);
  756.   }
  757.     /* find_call returns with appropriate record already read into
  758.        DA.record_buf and the return value is -1 for error or number of
  759.        seeks required on success.
  760.      */
  761.     
  762.   close_down(&DA);
  763.   return 0;
  764. }
  765. #endif /* #ifdef CALLSERVER */
  766.  
  767. struct cmds Callserver_cmds[] = {
  768.   "hostname", docallserver_hostname, 0,  0,  NULLCHAR,
  769. #ifdef CALLSERVER
  770.   "database", docallserver_databases,  0,  0,  NULLCHAR,
  771. #endif
  772.   NULLCHAR,
  773. };
  774.  
  775. /* Another public, headered in commands.h */
  776. int
  777. docallserver(argc,argv,p)
  778. int argc;
  779. char *argv[];
  780. void *p;
  781. {
  782.   return subcmd(Callserver_cmds, argc, argv, p);
  783. }
  784.  
  785. static int
  786. docallserver_hostname(argc,argv,p)
  787. int argc;
  788. char *argv[];
  789. void *p;
  790. {
  791.     if(argc < 2)
  792.     {
  793.         if(Callserver != NULLCHAR)
  794.       tprintf("The callserver's hostname is: %s\n",Callserver);
  795.         else
  796.         {
  797.             tprintf("Callserver not configured!\n");
  798.       tprintf("Usage: callserver <hostname>|<ip_address>\n");
  799.         }
  800.     }
  801.     else {
  802.         if(Callserver != NULLCHAR)
  803.             free(Callserver);
  804.         Callserver = strdup(argv[1]);
  805.     }
  806.     return 0;
  807. }
  808. #ifdef CALLSERVER
  809. static int
  810. docallserver_databases(argc,argv,p)
  811. int argc;
  812. char *argv[];
  813. void *p;
  814. {
  815. int t;
  816.  
  817.   if (argc < 2) {
  818.     for (t = 0; t < DATABASE_TYPES; t++)  {
  819.       tprintf("callserver database %s ", database_label[t]);
  820.       if (database[t] == NULLCHAR)  {
  821.         tprintf("not configured.\n");
  822.       }
  823.       else  tprintf("%s\n", database[t]);
  824.     }
  825.     return 0;
  826.   } else  { /* argc >= 2 */
  827.       for (t = 0; t < DATABASE_TYPES; t++)  {
  828.         if (strncmp(database_label[t],argv[1],strlen(argv[1])) == 0)  {
  829.           if (argc < 3) {
  830.             tprintf("callserver database %s ", database_label[t]);
  831.             if (database[t] == NULLCHAR)  tprintf("not configured\n");
  832.             else  tprintf("%s\n", database[t]);
  833.           } else  { /* argc >= 3  */
  834.             if (database[t] == NULLCHAR)  free(database[t]);
  835.             database[t] = strdup(argv[2]);
  836.           }
  837.           return 0; /* we have found our match with database_label[t] */
  838.         }
  839.       }
  840.       /* no match with database_label: which database?  */
  841.       tprintf("Usage: callserver database ");
  842.       for (t = 0; t < DATABASE_TYPES; t++)  {
  843.         tprintf("%s", database_label[t]);
  844.         if ( t < DATABASE_TYPES - 1)  tprintf("|");
  845.       }
  846.       tprintf(" <database drive:/path/filename>\n");
  847.       return -1;
  848.   }
  849.   /* not reached  */
  850. }
  851.  
  852. /* the last public of this module, also headered in commands.h  */
  853. int
  854. docdrom(argc,argv,p)
  855. int argc;
  856. char *argv[];
  857. void *p;
  858. {
  859. extern char *CDROM; /* declared above, this module  */
  860.  
  861.   if (argc < 2) {
  862.     if (CDROM == NULLCHAR)  {
  863.       tprintf("CDROM drive letter not specified\n");
  864.     }
  865.     else  tprintf("CDROM drive is \"%s\"\n", CDROM);
  866.     return 0;
  867.   }
  868.   else  {
  869.     if ((argv[1][2] == '\0')    &&
  870.         (isalpha(argv[1][0]))   &&
  871.         (argv[1][1] == ':'))  {
  872.           if (CDROM != NULLCHAR)  free(CDROM);
  873.           CDROM = strdup(argv[1]);
  874.           return 0;
  875.     }
  876.     else  {
  877.       tprintf("Usage: \"cdrom driveletter:\", e.g. \"cdrom s:\"\n");
  878.       return 1;
  879.     }
  880.   }
  881.   /* not reached  */
  882. }
  883. #endif  /* #ifdef CALLSERVER  */
  884.